home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / PASCAL / ALLSWAGS.ZIP / SWAGN-R.ZIP / NETWORK.SWG / 0042_Netware 3.11 API Library - NetStat.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1996-11-29  |  19.5 KB  |  495 lines
  1.  
  2. {
  3.             ╔══════════════════════════════════════════════════╗
  4.             ║     ┌╦═══╦┐┌╦═══╦┐┌╦═══╦┐┌╦═╗ ╦┐┌╦═══╦┐┌╔═╦═╗┐   ║
  5.             ║     │╠═══╩┘├╬═══╬┤└╩═══╦┐│║ ║ ║│├╬══      ║      ║
  6.             ║     └╩     └╩   ╩┘└╩═══╩┘└╩ ╚═╩┘└╩═══╩┘   ╩      ║
  7.             ║                                                  ║
  8.             ║     NetWare 3.11 API Library for Turbo Pascal    ║
  9.             ║                      by                          ║
  10.             ║                 S.Perevoznik                     ║
  11.             ║                     1996                         ║
  12.             ╚══════════════════════════════════════════════════╝
  13. }
  14.  
  15. Unit NetStat;
  16.  
  17. Interface
  18.  
  19. Uses NetConv;
  20.  
  21. Type PhysDiskStats = record
  22.       SystemElapsedTime : LongInt;
  23.       DiskChanell,
  24.       Diskremovable,
  25.       DriveType,
  26.       ControllerDriveNumber,
  27.       ControllerNumber,
  28.       ControllerType    : byte;
  29.       DriveSize         : longInt; { in 4096 byte blocks}
  30.       DriveCylinders    : word;
  31.       DriveHeads,
  32.       SectorsPerTrack   : byte;
  33.       DriveDefinition   : array [1..63] of char;
  34.       IOErrorCount      : word;
  35.       HotFixStart       : LongInt;
  36.       HotFixSize ,
  37.       HotFixBlockAvailable : word;
  38.       HotFixDisabled    : byte;
  39.      end;
  40.  
  41.      FileStats = record
  42.       SystemElapsedTime      : LongInt;
  43.       MaxOpenFiles           : Word;
  44.       MaxFilesOpened         : Word;
  45.       CurrOpenFiles          : Word;
  46.       TotalFilesOpened       : LongInt;
  47.       TotalReadRequests      : LongInt;
  48.       TotalWriteRequests     : LongInt;
  49.       CurrChangedFATSectors  : Word;
  50.       TotalChangedFATSectors : LongInt;
  51.       FATWriteErrors         : Word;
  52.       FatalFATWriteErrors    : Word;
  53.       FATScanErrors          : Word;
  54.       MaxIndexFilesOpened    : Word;
  55.       CurrOpenIndexedFiles   : Word;
  56.       AttachedIndexFiles     : Word;
  57.       AvailableIndexFiles    : Word;
  58.     end;
  59.  
  60.  
  61.       CacheStats = record
  62.             systemElapsedTime        : LongInt ;
  63.             cacheBufferCount         : Word ;
  64.             cacheBufferSize          : Word ;
  65.             dirtyCacheBuffers        : Word ;
  66.             cacheReadRequests        : LongInt ;
  67.             cacheWriteRequests       : LongInt ;
  68.             cacheHits                : LongInt ;
  69.             cacheMisses              : LongInt ;
  70.             physicalReadRequests     : LongInt ;
  71.             physicalWriteRequests    : LongInt ;
  72.             physicalReadErrors       : WORD ;
  73.             physicalWriteErrors      : WORD ;
  74.             cacheGetRequests         : LongInt ;
  75.             cacheFullWriteRequests   : LongInt ;
  76.             cachePartialWriteRequests: LongInt ;
  77.             backgroundDirtyWrites    : LongInt ;
  78.             backgroundAgedWrites     : LongInt ;
  79.             totalCacheWrites         : LongInt ;
  80.             cacheAllocations         : LongInt ;
  81.             thrashingCount           : WORD ;
  82.             LRUBlockWasDirtyCount    : WORD ;
  83.             readBeyondWriteCount     : WORD ;
  84.             fragmentedWriteCount     : WORD ;
  85.             cacheHitOnUnavailCount   : WORD ;
  86.             cacheBlockScrappedCount  : WORD ;
  87.            end;
  88.  
  89.     ServerLANIO = record
  90.              systemElapsedTime              : LongInt ;
  91.              maxRoutingBuffersAvail         : Word    ;
  92.              maxRoutingBuffersUsed          : Word    ;
  93.              routingBuffersInUse            : Word    ;
  94.              totalFileServicePackets        : LongInt ;
  95.              fileServicePacketsBuffered     : Word    ;
  96.              invalidConnPacketCount         : Word    ;
  97.              badLogicalConnCount            : Word    ;
  98.              packetsRcvdDuringProcCount     : Word    ;
  99.              reprocessedRequestCount        : Word    ;
  100.              badSequenceNumberPacketCount   : Word    ;
  101.              duplicateReplyCount            : Word    ;
  102.              acknowledgementsSent           : Word    ;
  103.              badRequestTypeCount            : Word    ;
  104.              attachDuringProcCount          : Word    ;
  105.              attachWhileAttachingCount      : Word    ;
  106.              forgedDetachRequestCount       : Word    ;
  107.              badConnNumberOnDetachCount     : Word    ;
  108.              detachDuringProcCount          : Word    ;
  109.              repliesCanceledCount           : Word    ;
  110.              hopCountDiscardCount           : Word    ;
  111.              unknownNetDiscardCount         : Word    ;
  112.              noDGroupBufferDiscardCount     : Word    ;
  113.              outPacketNoBufferDiscardCount  : Word    ;
  114.              IPXNotMyNetworkCount           : Word    ;
  115.              NetBIOSPropagationCount        : LongInt ;
  116.              totalOtherPackets              : LongInt ;
  117.              totalRoutedPackets             : LongInt ;
  118.           end;
  119.  
  120.        ServerMiscInfo = record
  121.              systemElapsedTime        : LongInt;
  122.              processorType            : BYTE;
  123.              reserved                 : BYTE;
  124.              serviceProcessCount      : BYTE;
  125.              serverUtilizationPercent : BYTE;
  126.              maxBinderyObjectsAvail   : WORD;
  127.              maxBinderyObjectsUsed    : WORD;
  128.              binderyObjectsInUse      : WORD;
  129.              serverMemoryInK          : Word ;
  130.              serverWastedMemoryInK    : Word ;
  131.              dynamicAreaCount         : Word ;
  132.              dynamicSpace1            : LongInt;
  133.              maxUsedDynamicSpace1     : LongInt;
  134.              dynamicSpaceInUse1       : LongInt;
  135.              dynamicSpace2            : LongInt;
  136.              maxUsedDynamicSpace2     : LongInt;
  137.              dynamicSpaceInUse2       : LongInt;
  138.              dynamicSpace3            : LongInt;
  139.              maxUsedDynamicSpace3     : LongInt;
  140.              dynamicSpaceInUse3       : LongInt;
  141.           end;
  142.  
  143.  
  144.  
  145.  
  146. Function GetPhysicalDiskStats(PhysicalDiskNumber : byte;
  147.                               Var PhysicalDiskStats : PhysDiskStats) : byte;
  148.  
  149.  
  150. Function GetFileSystemStats(Var FileSystemStats : FileStats ) : byte;
  151.  
  152. Function GetDiskCacheStats(Var DiskCacheStats : CacheStats ) : byte;
  153.  
  154.  
  155. Function GetServerLANIOStats( Var ServerLANIOStats : ServerLANIO ) : byte;
  156.  
  157. Function GetServerMiscInformation( Var ServerMiscInformation : ServerMiscInfo) : byte;
  158.  
  159.  
  160. {________________________ GetDiskUtilization _____________________________
  161. |
  162. | Output:   0               --  SUCCESSFUL
  163. |        network error code --  UNSUCCESSFUL
  164. |
  165. | Comments:
  166. |   This function returns the disk usage of a bindery object on a volume.
  167. |   To determine the total disk space used, this call should be made
  168. |   repetitively for all mounted volumes.  To determine the number of bytes
  169. |   of disk space used, the usedBlocks should be multiplied by the number of
  170. |   sectors and the bytes per sector. Currently network implementations
  171. |   allocate the disk in 8 512-byte sectors per block, which is 4K per block.
  172. |__________________________________________________________________________}
  173.  
  174.  
  175. Function GetDiskUtilization( VolumeNumber : byte;
  176.                              ObjectID     : LongInt;
  177.                              Var UsedDirectories : Word;
  178.                              Var UsedFiles       : Word;
  179.                              Var UsedBlocks      : Word) : byte;
  180.  
  181.  
  182.  
  183. Implementation
  184.  
  185. Uses Dos;
  186.  
  187. Function GetPhysicalDiskStats(PhysicalDiskNumber : byte;
  188.                               Var PhysicalDiskStats : PhysDiskStats) : byte;
  189.  
  190. Var
  191.   r : registers;
  192.   SendPacket  :  array [0..004] of byte;
  193.   ReplyPacket :  array [0..096] of byte;
  194.   WordPtr     : ^Word;
  195. Begin
  196.   SendPacket[2] := $D8;
  197.   SendPacket[3] := PhysicalDiskNumber;
  198.   WordPtr := addr(SendPacket);
  199.   WordPtr^ := 2;
  200.   WordPtr  := addr(ReplyPacket);
  201.   WordPtr^ := 94;
  202.  
  203.   r.BX := r.DS;
  204.   r.AH := $0E3;
  205.   r.DS := SEG(SendPacket);
  206.   r.SI := OFS(SendPacket);
  207.   r.ES := SEG(ReplyPacket);
  208.   r.DI := OFS(ReplyPacket);
  209.   intr($21,r);
  210.   r.DS := r.BX;
  211.   GetPhysicaldiskStats := r.AL;
  212.   if r.AL = 0 then
  213.     begin
  214.       move(ReplyPacket[2],PhysicalDiskStats,94);
  215.       with PhysicalDiskStats do
  216.         begin
  217.           SystemElapsedTime := GetLong(Addr(SystemElapsedTime));
  218.           DriveSize := GetLong(Addr(DriveSize));
  219.           DriveCylinders := GetWord(Addr(DriveCylinders));
  220.           IOErrorCount   := GetWord(Addr(IOErrorCount));
  221.           HotFixStart    := GetLong(Addr(HotFixStart));
  222.           HotFixSize     := GetWord(Addr(HotFixSize));
  223.           HotFixBlockAvailable := GetWord(Addr(HotFixBlockAvailable));
  224.         end;
  225.     end;
  226. end;
  227.  
  228. Function GetFileSystemStats(Var FileSystemStats : FileStats ) : byte;
  229. Var
  230.   r : registers;
  231.   SendPacket  :  array [0..003] of byte;
  232.   ReplyPacket :  array [0..030] of byte;
  233.   WordPtr     : ^Word;
  234. Begin
  235.   SendPacket[2] := $D4;
  236.   WordPtr := addr(SendPacket);
  237.   WordPtr^ := 1;
  238.   WordPtr  := addr(ReplyPacket);
  239.   WordPtr^ := 28;
  240.  
  241.   r.BX := r.DS;
  242.   r.AH := $0E3;
  243.   r.DS := SEG(SendPacket);
  244.   r.SI := OFS(SendPacket);
  245.   r.ES := SEG(ReplyPacket);
  246.   r.DI := OFS(ReplyPacket);
  247.   intr($21,r);
  248.   r.DS := r.BX;
  249.   GetFileSystemStats := r.AL;
  250.   if r.AL = 0 then
  251.     begin
  252.       move(ReplyPacket[2],FileSystemStats,28);
  253.       with FileSystemStats do
  254.         begin
  255.           SystemElapsedTime := GetLong(Addr(SystemElapsedTime));
  256.  
  257.           MaxOpenFiles      := GetWord(Addr(MaxOpenFiles));
  258.           MaxFilesOpened    := GetWord(Addr(MaxFilesOpened));
  259.           CurrOpenFiles     := GetWord(Addr(CurrOpenFiles));
  260.  
  261.           TotalFilesOpened  := GetLong(Addr(TotalFilesOpened));
  262.           TotalReadRequests := GetLong(Addr(TotalReadRequests));
  263.           TotalWriteRequests:= GetLong(Addr(TotalWriteRequests));
  264.  
  265.           CurrChangedFATSectors  := GetWord(Addr(CurrChangedFATSectors));
  266.           TotalChangedFATSectors := GetLong(Addr(TotalChangedFATSectors));
  267.           FATWriteErrors         := GetWord(Addr(FATWriteErrors));
  268.           FatalFATWriteErrors    := GetWord(Addr(FatalFATWriteErrors));
  269.           FATScanErrors          := GetWord(Addr(FATScanErrors));
  270.           MaxIndexFilesOpened    := GetWord(Addr(MaxIndexFilesOpened));
  271.           CurrOpenIndexedFiles   := GetWord(Addr(CurrOpenIndexedFiles));
  272.           AttachedIndexFiles     := GetWord(Addr(AttachedIndexFiles));
  273.           AvailableIndexFiles    := GetWord(Addr(AvailableIndexFiles));
  274.          end;
  275.        end;
  276.  
  277. end;
  278.  
  279. Function GetDiskCacheStats(Var DiskCacheStats : CacheStats ) : byte;
  280. Var
  281.   r : registers;
  282.   SendPacket  :  array [0..003] of byte;
  283.   ReplyPacket :  array [0..080] of byte;
  284.   WordPtr     : ^Word;
  285. Begin
  286.   SendPacket[2] := $D6;
  287.   WordPtr := addr(SendPacket);
  288.   WordPtr^ := 1;
  289.   WordPtr  := addr(ReplyPacket);
  290.   WordPtr^ := 78;
  291.  
  292.   r.BX := r.DS;
  293.   r.AH := $0E3;
  294.   r.DS := SEG(SendPacket);
  295.   r.SI := OFS(SendPacket);
  296.   r.ES := SEG(ReplyPacket);
  297.   r.DI := OFS(ReplyPacket);
  298.   intr($21,r);
  299.   r.DS := r.BX;
  300.   GetDiskCacheStats := r.AL;
  301.   if r.AL = 0 then
  302.     begin
  303.       move(ReplyPacket[2],DiskCacheStats,78);
  304.       with DiskCacheStats do
  305.         begin
  306.  
  307.             systemElapsedTime        := GetLong(Addr(systemElapsedTime        ));
  308.             cacheBufferCount         := GetWord(Addr(cacheBufferCount         ));
  309.             cacheBufferSize          := GetWord(Addr(cacheBufferSize          ));
  310.             dirtyCacheBuffers        := GetWord(Addr(dirtyCacheBuffers        ));
  311.             cacheReadRequests        := GetLong(Addr(cacheReadRequests        ));
  312.             cacheWriteRequests       := GetLong(Addr(cacheWriteRequests       ));
  313.             cacheHits                := GetLong(Addr(cacheHits                ));
  314.             cacheMisses              := GetLong(Addr(cacheMisses              ));
  315.             physicalReadRequests     := GetLong(Addr(physicalReadRequests     ));
  316.             physicalWriteRequests    := GetLong(Addr(physicalWriteRequests    ));
  317.             physicalReadErrors       := GetWORD(Addr(physicalReadErrors       ));
  318.             physicalWriteErrors      := GetWORD(Addr(physicalWriteErrors      ));
  319.             cacheGetRequests         := GetLong(Addr(cacheGetRequests         ));
  320.             cacheFullWriteRequests   := GetLong(Addr(cacheFullWriteRequests   ));
  321.             cachePartialWriteRequests:= GetLong(Addr(cachePartialWriteRequests));
  322.             backgroundDirtyWrites    := GetLong(Addr(backgroundDirtyWrites    ));
  323.             backgroundAgedWrites     := GetLong(Addr(backgroundAgedWrites     ));
  324.             totalCacheWrites         := GetLong(Addr(totalCacheWrites         ));
  325.             cacheAllocations         := GetLong(Addr(cacheAllocations         ));
  326.             thrashingCount           := GetWORD(Addr(thrashingCount           ));
  327.             LRUBlockWasDirtyCount    := GetWORD(Addr(LRUBlockWasDirtyCount    ));
  328.             readBeyondWriteCount     := GetWORD(Addr(readBeyondWriteCount     ));
  329.             fragmentedWriteCount     := GetWORD(Addr(fragmentedWriteCount     ));
  330.             cacheHitOnUnavailCount   := GetWORD(Addr(cacheHitOnUnavailCount   ));
  331.             cacheBlockScrappedCount  := GetWORD(Addr(cacheBlockScrappedCount  ));
  332.          end;
  333.  end;
  334. end;
  335.  
  336. Function GetServerLANIOStats( Var ServerLANIOStats : ServerLANIO ) : byte;
  337. Var
  338.   r : registers;
  339.   SendPacket  :  array [0..003] of byte;
  340.   ReplyPacket :  array [0..068] of byte;
  341.   WordPtr     : ^Word;
  342. Begin
  343.   SendPacket[2] := $E7;
  344.   WordPtr := addr(SendPacket);
  345.   WordPtr^ := 1;
  346.   WordPtr  := addr(ReplyPacket);
  347.   WordPtr^ := 66;
  348.  
  349.   r.BX := r.DS;
  350.   r.AH := $0E3;
  351.   r.DS := SEG(SendPacket);
  352.   r.SI := OFS(SendPacket);
  353.   r.ES := SEG(ReplyPacket);
  354.   r.DI := OFS(ReplyPacket);
  355.   intr($21,r);
  356.   r.DS := r.BX;
  357.   GetServerLANIOStats := r.AL;
  358.   if r.AL = 0 then
  359.     begin
  360.       move(ReplyPacket[2],ServerLANIOStats,66);
  361.       with ServerLANIOStats do
  362.         begin
  363.              systemElapsedTime              := GetLong(Addr(systemElapsedTime                ));
  364.              maxRoutingBuffersAvail         := GetWord(Addr(maxRoutingBuffersAvail           ));
  365.              maxRoutingBuffersUsed          := GetWord(Addr(maxRoutingBuffersUsed            ));
  366.              routingBuffersInUse            := GetWord(Addr(routingBuffersInUse              ));
  367.              totalFileServicePackets        := GetLong(Addr(totalFileServicePackets          ));
  368.              fileServicePacketsBuffered     := GetWord(Addr(fileServicePacketsBuffered       ));
  369.              invalidConnPacketCount         := GetWord(Addr(invalidConnPacketCount           ));
  370.              badLogicalConnCount            := GetWord(Addr(badLogicalConnCount              ));
  371.              packetsRcvdDuringProcCount     := GetWord(Addr(packetsRcvdDuringProcCount       ));
  372.              reprocessedRequestCount        := GetWord(Addr(reprocessedRequestCount          ));
  373.              badSequenceNumberPacketCount   := GetWord(Addr(badSequenceNumberPacketCount     ));
  374.              duplicateReplyCount            := GetWord(Addr(duplicateReplyCount              ));
  375.              acknowledgementsSent           := GetWord(Addr(acknowledgementsSent             ));
  376.              badRequestTypeCount            := GetWord(Addr(badRequestTypeCount              ));
  377.              attachDuringProcCount          := GetWord(Addr(attachDuringProcCount            ));
  378.              attachWhileAttachingCount      := GetWord(Addr(attachWhileAttachingCount        ));
  379.              forgedDetachRequestCount       := GetWord(Addr(forgedDetachRequestCount         ));
  380.              badConnNumberOnDetachCount     := GetWord(Addr(badConnNumberOnDetachCount       ));
  381.              detachDuringProcCount          := GetWord(Addr(detachDuringProcCount            ));
  382.              repliesCanceledCount           := GetWord(Addr(repliesCanceledCount             ));
  383.              hopCountDiscardCount           := GetWord(Addr(hopCountDiscardCount             ));
  384.              unknownNetDiscardCount         := GetWord(Addr(unknownNetDiscardCount           ));
  385.              noDGroupBufferDiscardCount     := GetWord(Addr(noDGroupBufferDiscardCount       ));
  386.              outPacketNoBufferDiscardCount  := GetWord(Addr(outPacketNoBufferDiscardCount    ));
  387.              IPXNotMyNetworkCount           := GetWord(Addr(IPXNotMyNetworkCount             ));
  388.              NetBIOSPropagationCount        := GetLong(Addr(NetBIOSPropagationCount          ));
  389.              totalOtherPackets              := GetLong(Addr(totalOtherPackets                ));
  390.              totalRoutedPackets             := GetLong(Addr(totalRoutedPackets               ));
  391.            end;
  392.           end;
  393.     end;
  394.  
  395. Function GetServerMiscInformation( Var ServerMiscInformation : ServerMiscInfo) : byte;
  396. Var
  397.   r : registers;
  398.   SendPacket  :  array [0..003] of byte;
  399.   ReplyPacket :  array [0..058] of byte;
  400.   WordPtr     : ^Word;
  401. Begin
  402.   SendPacket[2] := $E8;
  403.   WordPtr := addr(SendPacket);
  404.   WordPtr^ := 1;
  405.   WordPtr  := addr(ReplyPacket);
  406.   WordPtr^ := 56;
  407.  
  408.   r.BX := r.DS;
  409.   r.AH := $0E3;
  410.   r.DS := SEG(SendPacket);
  411.   r.SI := OFS(SendPacket);
  412.   r.ES := SEG(ReplyPacket);
  413.   r.DI := OFS(ReplyPacket);
  414.   intr($21,r);
  415.   GetServerMiscInformation := r.AL;
  416.   r.DS := r.BX;
  417.   if r.AL = 0 then
  418.     begin
  419.       move(ReplyPacket[2],ServerMiscInformation,56);
  420.       with ServerMiscInformation do
  421.         begin
  422.              systemElapsedTime        := GetLong(Addr(systemElapsedTime      ));
  423.              maxBinderyObjectsAvail   := GetWORD(Addr(maxBinderyObjectsAvail ));
  424.              maxBinderyObjectsUsed    := GetWORD(Addr(maxBinderyObjectsUsed  ));
  425.              binderyObjectsInUse      := GetWORD(Addr(binderyObjectsInUse    ));
  426.              serverMemoryInK          := GetWord(Addr(serverMemoryInK        ));
  427.              serverWastedMemoryInK    := GetWord(Addr(serverWastedMemoryInK  ));
  428.              dynamicAreaCount         := GetWord(Addr(dynamicAreaCount       ));
  429.              dynamicSpace1            := GetLong(Addr(dynamicSpace1          ));
  430.              maxUsedDynamicSpace1     := GetLong(Addr(maxUsedDynamicSpace1   ));
  431.              dynamicSpaceInUse1       := GetLong(Addr(dynamicSpaceInUse1     ));
  432.              dynamicSpace2            := GetLong(Addr(dynamicSpace2          ));
  433.              maxUsedDynamicSpace2     := GetLong(Addr(maxUsedDynamicSpace2   ));
  434.              dynamicSpaceInUse2       := GetLong(Addr(dynamicSpaceInUse2     ));
  435.              dynamicSpace3            := GetLong(Addr(dynamicSpace3          ));
  436.              maxUsedDynamicSpace3     := GetLong(Addr(maxUsedDynamicSpace3   ));
  437.              dynamicSpaceInUse3       := GetLong(Addr(dynamicSpaceInUse3     ));
  438.            end;
  439.           end;
  440.         end;
  441.  
  442. Function GetDiskUtilization( VolumeNumber : byte;
  443.                              ObjectID     : LongInt;
  444.                              Var UsedDirectories : Word;
  445.                              Var UsedFiles       : Word;
  446.                              Var UsedBlocks      : Word) : byte;
  447.  
  448. { äáΓ∞ ¿¡Σ«α¼áµ¿ε «í ¿ß»«½∞º«óá¡¿¿ ñ¿ß¬á}
  449. Var
  450.   r : registers;
  451.   SendPacket  :  array [0..08] of byte;
  452.   ReplyPacket :  array [0..13] of byte;
  453.   WordPtr     : ^Word;
  454. Begin
  455.   SendPacket[2] := 14;
  456.   SendPacket[3] := VolumeNumber;
  457.   ObjectID := GetLong(Addr(ObjectID));
  458.   move(ObjectID,SendPacket[4],4);
  459.  
  460.   WordPtr := addr(SendPacket);
  461.   WordPtr^ := 6;
  462.   WordPtr  := addr(ReplyPacket);
  463.   WordPtr^ := 11;
  464.  
  465.   r.BX := r.DS;
  466.   r.AH := $0E3;
  467.   r.DS := SEG(SendPacket);
  468.   r.SI := OFS(SendPacket);
  469.   r.ES := SEG(ReplyPacket);
  470.   r.DI := OFS(ReplyPacket);
  471.   intr($21,r);
  472.   GetDiskUtilization := r.AL;
  473.   r.DS := r.BX;
  474.   if r.AL = 0 then
  475.     begin
  476.       UsedDirectories := GetWord(Addr(ReplyPacket[7]));
  477.       UsedFiles       := GetWord(Addr(ReplyPacket[9]));
  478.       UsedBlocks      := GetWord(Addr(ReplyPacket[11]));
  479.      end;
  480. end;
  481.  
  482. end.
  483.  
  484.  
  485.  
  486.  
  487.  
  488.  
  489.  
  490.  
  491.  
  492.  
  493.  
  494.  
  495.